Elements of Assembly Language

Numeric Labels

Local numeric labels allow compilers and programmers to use names temporarily. A numeric label consists of a digit (between 0 and 9) followed by a colon. These ten local symbol names can be reused any number of times throughout the program. As with alphanumeric labels, a numeric label assigns the current value of the location counter to the symbol.

Although multiple numeric labels with the same digit may be used within the same program, only the next definition and the most recent previous definition of a label can be referenced:

• To refer to the most recent previous definition of a local numeric label, write digit b, (using the same digit as when you defined the label).
• To refer to the next definition of a numeric label, write digit f.

The Scope of a Label

The scope of a label is the distance over which it is visible to (and referenceable by) other parts of the program. Normally, a label that tags a location or data is visible only within the current assembly unit.

The .globl directive (described in Chapter 4) may be used to make a label external. In this case, the symbol is visible to other assembly units at link time.

Numeric Constants

A numeric constant is a token that starts with a digit. Numeric constants can be decimal, hexadecimal, or octal. The following restrictions apply:

• Decimal constants contain only digits between 0 and 9, and normally aren't longer than 32 bits--having a value between -2,147,483,648 and 2,147,483,647 (values that don't fit in 32 bits are bignums , which are legal but which should fit within the designated format). Decimal constants cannot contain leading zeros or commas.
• Hexadecimal constants start with 0x (or 0X), followed by between one and eight decimal or hexadecimal digits (0 through 9, `a' through `f', and `A' through `F'). Values that don't fit in 32 bits are bignums.
• Octal constants start with 0, followed by from one to eleven octal digits (0 through 7). Values that don't fit in 32 bits are bignums.

Character Constants

A single-character constant consists of a single quote ( ' ) followed by any ASCII character. The constant's value is the code for the given character.

String Constants

A string constant is a sequence of 0 or more ASCII characters surrounded by quotation marks ( "characters" ).

Floating Point Constants

The general lexical form of a floating point number is:

0flt_char [{ +- }] dec ...[ .][ dec ...][ exp_char [{ +- }][ dec ...]]

where:

Item	Description
flt_char	a required type specification character (see the following table)
[{+-}]	the optional occurrence of either + or -, but not both
dec ...	a required sequence of 1 or more decimal digits
[.]	a single optional "."
[dec ...]	an optional sequence of 1 or more decimal digits
[exp_char ]	an optional exponent delimiter character (see the following table)

The type specification character, flt_char , specifies the type and representation of the constructed number; the set of legal type specification characters with the processor architecture, as shown here:

Architecture	flt_char	exp_char
M98000	{dDfF}	{eE}
i386	{fFdDxX}	{eE}

On the M68000 architecture, 0b can be used to specify an immediate hexadecimal bit pattern. For example:

fmoves #0b7f80001,fp0

moves the signaling Nan into the register fp0 and

fmoves #0x7f80001,fp0

moves the decimal number 2,139,095,041 (0x7f80001 in hexadecimal) into the register fp0.

When floating-point constants are used as arguments to the .single and .double directives, the type specification character isn't actually used in determining the type of the number. For convenience, ror Rcan be used consistently to specify all types of floating-point numbers.

Collectively, all floating point numbers, together with quad and octal scalars, are called Bignums. When as requires a Bignum, a 32-bit scalar quantity may also be used.

Floating point constants are internally represented as flonums, in a machine-independent, precision-independent floating point format (for accurate cross-assembly).